package com.gdzn.netty.server.handler;

import cn.hutool.json.JSONUtil;
import com.gdzn.common.core.utils.StringUtils;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

@Slf4j
public class JsonDecoder extends ByteToMessageDecoder {

    private final StringBuilder buffer = new StringBuilder();
    public static final String  JSON_REGEX = "}{";
    public static final String  MSG_TYPE = "msgType";

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        // 将ByteBuf中的数据转换为字符串
        String incomingString = in.toString(in.readerIndex(), in.readableBytes(), CharsetUtil.UTF_8);
        System.out.println("******incomingString:"+incomingString);
        buffer.append(incomingString); // 累积到buffer中
        in.readerIndex(in.writerIndex()); // 更新读取位置

        // 尝试从buffer中解析JSON
        if (isCompleteJson(buffer.toString())) {
            try {
                out.add(buffer.toString()); // 解析成功，添加到输出列表
                buffer.setLength(0); // 清空buffer，准备下一次读取
            } catch (Exception e) {
                // JSON解析失败，处理错误
                ctx.close(); // 解析错误可能需要关闭连接
            }
        }else if(buffer.toString().contains(JSON_REGEX)){
            String bufStr = buffer.toString();
            String[] arrStr = bufStr.split("}\\{");
            System.out.println("***arrStr.length****:"+arrStr.length);
            int strLength = bufStr.length();
            int lastLength = bufStr.lastIndexOf("}{");
            String lastStr = "";//缓存buffer数据拆分后，剩余的不完整json数据
            for(int i=0;i<arrStr.length;i++){
                String bufferStr = arrStr[i];
                System.out.println(i+"****数组原始bufferStr:"+bufferStr);
                //从第二开始加上{
                if(i>0){
                    bufferStr = "{" + bufferStr;
                }
                //第一个到倒数第二个后面要加}
                if(i<arrStr.length-1){
                    bufferStr = bufferStr + "}";
                }
                //最后一个，如果bufStr最后两个字符为}{，数组最后一个元素要加}
                if(i==arrStr.length-1&&strLength==lastLength+2){
                    bufferStr = bufferStr + "}";
                    lastStr = "{";
                }
                if(isCompleteJson(bufferStr)){
                    try {
                        out.add(bufferStr); //解析成功，添加到输出列表
                    }catch (Exception e){
                        System.out.println("****按}{拆分***out****Exception***");
                    }
                }
                //最后一个如果不是json，则当做下一个json的开头，且存放到buffer
                if(i==arrStr.length-1&&!isCompleteJson(bufferStr)){
                    lastStr = bufferStr;
                }
                System.out.println(i+"****最后组装成的bufferStr:"+bufferStr);
            }
            buffer.setLength(0); // 先清空buffer，准备下一次读取
            buffer.append(lastStr); // 累积到buffer中
        }
    }

    private static String jsonAnalyse(String jsonStr,List<Object> out) {
        if(StringUtils.isBlank(jsonStr)){
            return "";
        }
        //判断是否包含"}{"
        int idx = jsonStr.indexOf(JSON_REGEX);
        if(idx == -1){
            return jsonStr;
        }else{
            String tmp = jsonStr.substring(0,idx+1);
            boolean isVaildJson = isCompleteJson(tmp);
            if(isVaildJson){
                if(tmp.contains(MSG_TYPE)){
                    System.out.println("******解析成功字符串：******"+tmp);
                    out.add(tmp);
                }else{
                    System.out.println("******丢弃字符串：******"+tmp);
                }
            }else{
                System.out.println("******丢弃字符串：******"+tmp);
            }
            //System.out.println("==="+s.substring(idx+1,s.length()));
            return jsonAnalyse(jsonStr.substring(idx+1,jsonStr.length()),out);
        }
    }

    /**
     * 判断是否有效json
     * @param jsonStr
     * @return
     */
    private static boolean isCompleteJson(String jsonStr) {
        try {
            JsonParser.parseString(jsonStr);
        } catch (JsonSyntaxException e) {
            System.out.println("******不是有效的json******"+jsonStr);
            return false;
        }
        return true;
    }

}
